#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
GitLab分析界面
基于核心指标和四维评估体系的全新实现
"""

import os
from datetime import datetime, timedelta
from typing import Dict

import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import streamlit as st
from dotenv import load_dotenv
from loguru import logger

from core.report_generator import ContributorReportGenerator
from gitlab_timescale import TimescaleDBManager

# 加载环境变量
load_dotenv()
from gitlab_timescale.config import get_config
from gitlab_timescale.core_analyzer import GitLabCoreAnalyzer


class GitLabInterface:
    """GitLab分析界面
    
    专注于以下核心功能：
    1. 核心指标展示：annual_commit_rate, month_commit_rate, annual_total_additions, month_total_additions
    2. 四维评估体系：工作习惯、项目参与度、持续性评估、协作能力、综合评级
    """

    def __init__(self):
        """初始化界面"""
        config = get_config()
        self.db_manager = TimescaleDBManager(
            connection_string=config.database.connection_string,
            min_connections=config.database.min_connections,
            max_connections=config.database.max_connections
        )
        self.analyzer = GitLabCoreAnalyzer(self.db_manager)

    def render_sidebar_config(self) -> Dict:
        """渲染侧边栏配置"""
        st.sidebar.markdown("### 🔧 分析配置")

        # GitLab URL配置已移除，系统将自动分析所有配置的GitLab实例
        gitlab_url = None

        # 时间范围配置
        st.sidebar.markdown("#### 📅 时间范围")
        date_range = st.sidebar.date_input(
            "选择日期范围",
            value=(datetime.now() - timedelta(days=365), datetime.now()),
            help="分析的时间范围",
            key="gitlab_date_range"
        )

        start_date = date_range[0] if len(date_range) > 0 else None
        end_date = date_range[1] if len(date_range) > 1 else None

        # 活跃度配置
        min_active_days = st.sidebar.slider(
            "最小活跃天数",
            min_value=1,
            max_value=365,
            value=50,
            help="筛选活跃天数大于此值的贡献者",
            key="gitlab_min_active_days"
        )

        # 数据范围配置
        st.sidebar.markdown("#### 📈 数据范围")
        data_range = st.sidebar.radio(
            "选择数据范围",
            options=["全年数据", "半年数据"],
            index=0,
            help="选择分析使用的数据范围",
            key="gitlab_data_range"
        )

        use_6month_view = (data_range == "半年数据")

        # 显示配置
        st.sidebar.markdown("#### 📊 显示配置")
        show_detailed_metrics = st.sidebar.checkbox(
            "显示详细指标",
            value=True,
            help="是否显示所有详细的评估指标",
            key="gitlab_show_detailed_metrics"
        )

        show_trend_analysis = st.sidebar.checkbox(
            "显示趋势分析",
            value=True,
            help="是否显示全年与半年数据的趋势对比",
            key="gitlab_show_trend_analysis"
        )

        max_contributors = st.sidebar.slider(
            "最大显示人数",
            min_value=5,
            max_value=100,
            value=int(os.getenv('GITLAB_DEFAULT_MAX_CONTRIBUTORS', '50')),
            help="排行榜最多显示的贡献者数量",
            key="gitlab_max_contributors"
        )

        return {
            'gitlab_url': gitlab_url if gitlab_url else None,
            'start_date': start_date,
            'end_date': end_date,
            'min_active_days': min_active_days,
            'use_6month_view': use_6month_view,
            'show_detailed_metrics': show_detailed_metrics,
            'show_trend_analysis': show_trend_analysis,
            'max_contributors': max_contributors
        }

    def display_summary_dashboard(self, config: Dict):
        """显示汇总仪表板"""
        st.markdown("## 📊 团队概览")

        # 获取汇总统计
        summary_stats = self.analyzer.get_summary_stats(
            gitlab_url=config['gitlab_url'],
            start_date=config['start_date'],
            end_date=config['end_date'],
            min_active_days=config['min_active_days'],
            use_6month_view=config['use_6month_view']
        )

        if not summary_stats:
            st.warning("暂无数据")
            return

        # 关键指标卡片
        col1, col2, col3, col4 = st.columns(4)

        with col1:
            st.metric(
                "总贡献者数",
                summary_stats.get('total_contributors', 0),
                help="满足筛选条件的贡献者总数"
            )

        with col2:
            st.metric(
                "平均月度提交率",
                f"{summary_stats.get('avg_monthly_commit_rate', 0):.1f}",
                help="所有贡献者的平均月度提交率"
            )

        with col3:
            st.metric(
                "平均年度新增行数",
                f"{summary_stats.get('avg_annual_additions', 0):,.0f}",
                help="所有贡献者的平均年度新增代码行数"
            )

        with col4:
            st.metric(
                "平均综合评分",
                f"{summary_stats.get('avg_comprehensive_score', 0):.1f}",
                help="所有贡献者的平均综合评分（满分1000）"
            )

        # 评级分布饼图
        if 'rating_distribution' in summary_stats:
            st.markdown("### 📈 综合评级分布")

            rating_data = summary_stats['rating_distribution']
            fig = px.pie(
                values=list(rating_data.values()),
                names=list(rating_data.keys()),
                title="贡献者综合评级分布",
                color_discrete_map={
                    '优秀': '#2E8B57',
                    '良好': '#4682B4',
                    '一般': '#DAA520',
                    '需改进': '#CD5C5C'
                }
            )
            st.plotly_chart(fig, use_container_width=True)

    def display_top_contributors(self, config: Dict):
        """显示顶级贡献者排行榜"""
        st.markdown("## 🚀 贡献者排行榜")
        st.markdown("*按综合评分倒序排列*")

        # 获取顶级贡献者数据
        df = self.analyzer.get_top_contributors(
            gitlab_url=config['gitlab_url'],
            start_date=config['start_date'],
            end_date=config['end_date'],
            min_active_days=config['min_active_days'],
            limit=config['max_contributors'],
            use_6month_view=config['use_6month_view']
        )

        if df.empty:
            st.warning("暂无数据")
            return

        # 识别半年提交血崩的开发者
        df = self._identify_commit_decline(df)

        # 核心指标表格
        st.markdown("### 📋 核心指标排行")
        
        # 指标定义说明
        with st.expander("📖 指标定义说明", expanded=False):
            st.markdown("""
            **核心指标定义规则：**
            
            📊 **提交指标**
            - **月度提交率**：基于活跃时间跨度计算的月均提交次数 = 总提交数 ÷ 活跃天数 × 30.44天/月
            - **年度提交率**：基于活跃时间跨度计算的年均提交次数 = 总提交数 ÷ 活跃天数 × 365天/年
            
            📈 **代码量指标**
            - **月度新增行数**：基于活跃时间跨度计算的月均新增代码行数
            - **年度新增行数**：基于活跃时间跨度计算的年均新增代码行数
            
            🏆 **评估指标**
            - **综合评分**：基于多维度算法计算的综合贡献评分（0-1000分）
            - **综合评级**：根据综合评分划分的等级（S/A/B/C/D）
            
            📅 **活跃度指标**
            - **活跃天数**：有提交记录的天数总计
            - **项目参与数**：参与的项目总数
            - **活跃时间跨度**：从首次提交到最后提交的时间范围
            
            🎯 **综合评估体系（总分1250分）**
            
            **🏢 项目参与度评估（450分）**
            - **月提交率**（200分）：基于活跃时间跨度的月均提交频率评分
            - **月新增行数**（200分）：月均代码新增量的贡献度评分
            - **项目数量**（50分）：参与项目的广度评估
            
            **📅 持续性评估（250分）**
            - **活跃天数**（100分）：总活跃天数的持续性评分
            - **一致性比例**（100分）：提交频率的稳定性和规律性评估
            - **月度提交**（50分）：月度提交分布的均匀性评分
            
            **⏰ 工作习惯评估（250分）**
            - **工作时间**（60分）：工作时间分布的合理性评估
            - **工作日规律**（115分）：工作日提交规律性和专业性评分
            - **活跃时间**（75分）：活跃时间段的集中度和效率评估
            
            **🤝 协作能力评估（300分）**
            - **协作广度**（120分）：跨项目协作和团队合作能力评估
            - **技术影响力**（130分）：代码质量和技术贡献的影响力评分
            - **团队贡献**（50分）：团队协作中的贡献度和配合度评估
            
            ⚠️ **注意**：所有比率指标都基于实际活跃时间跨度计算，更准确反映开发者的真实贡献频率。综合评估体系采用多维度算法，全面评估开发者的技术能力和协作水平。
            """)

        # 检查数据框中实际存在的列
        available_columns = df.columns.tolist()

        # 基础必需列
        base_columns = [
            'canonical_name', 'all_emails',
            'month_commit_rate', 'annual_commit_rate',
            'month_total_additions', 'annual_total_additions',
            'comprehensive_score', 'comprehensive_rating'
        ]

        # 可选的新增列（如果存在则添加）- 使用实际的字段名
        optional_columns = [
            'total_projects', 'active_days', 'additions_ratio',
            'consistency_ratio', 'projects_per_year', 'active_days_span',
            'max_commits_per_project', 'feature_commits', 'bugfix_commits',
            # 半年活跃度指标
            'recent_6m_annual_commit_rate', 'recent_6m_annual_additions',
            'recent_6m_active_days', 'recent_6m_total_projects',
            # 'work_hour_ratio', 'weekend_ratio',
            'first_commit_date', 'last_commit_date'
        ]

        # 构建实际可用的显示列
        display_columns = base_columns.copy()
        for col in optional_columns:
            if col in available_columns:
                display_columns.insert(-2, col)  # 在综合评分前插入

        display_df = df[display_columns].copy()

        # 格式化数字为带千位分隔符的格式
        # 提交数量：转换为千位单位并添加千位分隔符
        display_df['month_commit_rate'] = (display_df['month_commit_rate'] / 1000).round(2).apply(
            lambda x: f"{x:,.2f}K")
        display_df['annual_commit_rate'] = (display_df['annual_commit_rate'] / 1000).round(2).apply(
            lambda x: f"{x:,.2f}K")

        # 新增行数：添加千位分隔符
        display_df['month_total_additions'] = (display_df['month_total_additions'] / 1000).round(1).apply(
            lambda x: f"{x:,.1f}K")
        display_df['annual_total_additions'] = (display_df['annual_total_additions'] / 1000).round(1).apply(
            lambda x: f"{x:,.1f}K")

        # 百分比字段：转换为百分比并添加千位分隔符
        if 'additions_ratio' in display_df.columns:
            display_df['additions_ratio'] = display_df['additions_ratio'].round(0).astype(int).apply(
                lambda x: f"{x:,}%")
        if 'consistency_ratio' in display_df.columns:
            display_df['consistency_ratio'] = display_df['consistency_ratio'].round(0).astype(int).apply(
                lambda x: f"{x:,}%")

        # 整数字段：添加千位分隔符
        if 'total_projects' in display_df.columns:
            display_df['total_projects'] = display_df['total_projects'].astype(int).apply(lambda x: f"{x:,}")
        if 'active_days' in display_df.columns:
            display_df['active_days'] = display_df['active_days'].astype(int).apply(lambda x: f"{x:,}")

        # 年均项目数：保留小数并添加千位分隔符
        if 'projects_per_year' in display_df.columns:
            display_df['projects_per_year'] = display_df['projects_per_year'].round(1).apply(lambda x: f"{x:,.1f}")

        # 新增字段格式化
        if 'active_days_span' in display_df.columns:
            display_df['active_days_span'] = display_df['active_days_span'].astype(int).apply(lambda x: f"{x:,}")
        if 'max_commits_per_project' in display_df.columns:
            display_df['max_commits_per_project'] = display_df['max_commits_per_project'].astype(int).apply(
                lambda x: f"{x:,}")
        if 'feature_commits' in display_df.columns:
            display_df['feature_commits'] = display_df['feature_commits'].astype(int).apply(lambda x: f"{x:,}")
        if 'bugfix_commits' in display_df.columns:
            display_df['bugfix_commits'] = display_df['bugfix_commits'].astype(int).apply(lambda x: f"{x:,}")
        if 'work_hour_ratio' in display_df.columns:
            display_df['work_hour_ratio'] = display_df['work_hour_ratio'].round(0).astype(int).apply(
                lambda x: f"{x:,}%")
        if 'weekend_ratio' in display_df.columns:
            display_df['weekend_ratio'] = display_df['weekend_ratio'].round(0).astype(int).apply(lambda x: f"{x:,}%")

        # 半年活跃度指标格式化
        if 'recent_6m_annual_commit_rate' in display_df.columns:
            display_df['recent_6m_annual_commit_rate'] = (display_df['recent_6m_annual_commit_rate'] / 1000).round(
                2).apply(
                lambda x: f"{x:,.2f}K")
        if 'recent_6m_annual_additions' in display_df.columns:
            display_df['recent_6m_annual_additions'] = (display_df['recent_6m_annual_additions'] / 1000).round(1).apply(
                lambda x: f"{x:,.1f}K")
        if 'recent_6m_active_days' in display_df.columns:
            display_df['recent_6m_active_days'] = display_df['recent_6m_active_days'].astype(int).apply(
                lambda x: f"{x:,}")
        if 'recent_6m_total_projects' in display_df.columns:
            display_df['recent_6m_total_projects'] = display_df['recent_6m_total_projects'].astype(int).apply(
                lambda x: f"{x:,}")

        # 时间字段格式化
        if 'first_commit_date' in display_df.columns:
            display_df['first_commit_date'] = pd.to_datetime(display_df['first_commit_date']).dt.strftime('%Y-%m-%d')
        if 'last_commit_date' in display_df.columns:
            display_df['last_commit_date'] = pd.to_datetime(display_df['last_commit_date']).dt.strftime('%Y-%m-%d')

        # 综合评分：添加千位分隔符
        display_df['comprehensive_score'] = display_df['comprehensive_score'].round(0).astype(int).apply(
            lambda x: f"{x:,}")

        # 动态生成列名映射
        column_names = ['姓名', '邮箱', '月度提交数(K)', '年度提交数(K)', '月度新增行数(K)', '年度新增行数(K)']

        # 根据实际存在的可选列添加对应的中文名
        for col in optional_columns:
            if col in display_df.columns:
                if col == 'total_projects':
                    column_names.append('项目总数')
                elif col == 'active_days':
                    column_names.append('活跃天数')
                elif col == 'additions_ratio':
                    column_names.append('新增代码占比%')
                elif col == 'consistency_ratio':
                    column_names.append('一致性比例%')
                elif col == 'projects_per_year':
                    column_names.append('年均项目数')
                elif col == 'active_days_span':
                    column_names.append('活跃天数跨度')
                elif col == 'max_commits_per_project':
                    column_names.append('单项目最大提交数')
                elif col == 'feature_commits':
                    column_names.append('功能提交数')
                elif col == 'bugfix_commits':
                    column_names.append('修复提交数')
                # 半年活跃度指标
                elif col == 'recent_6m_annual_commit_rate':
                    column_names.append('半年年提交数(K)')
                elif col == 'recent_6m_annual_additions':
                    column_names.append('半年年新增行数(K)')
                elif col == 'recent_6m_active_days':
                    column_names.append('半年活跃天数')
                elif col == 'recent_6m_total_projects':
                    column_names.append('半年项目总数')
                # elif col == 'work_hour_ratio':
                #     column_names.append('工作时间占比%')
                # elif col == 'weekend_ratio':
                #     column_names.append('周末工作占比%')
                elif col == 'first_commit_date':
                    column_names.append('首次提交时间')
                elif col == 'last_commit_date':
                    column_names.append('最近提交时间')

        # 添加最后两列
        column_names.extend(['综合评分', '综合评级'])

        display_df.columns = column_names

        # 添加排名
        display_df.insert(0, '排名', range(1, len(display_df) + 1))

        st.dataframe(
            display_df,
            use_container_width=True,
            hide_index=True
        )

        # 智能报告生成
        self._render_ai_report_section(df)

        # 可视化图表
        self._render_ranking_charts(df)

        # 半年提交量骤降分析图表
        self._render_decline_analysis_charts(df)

    def _render_ranking_charts(self, df: pd.DataFrame):
        """渲染排行榜图表"""
        st.markdown("### 📊 可视化分析")

        # 第一部分：基础指标对比
        st.markdown("#### 📈 基础指标对比")
        col1, col2 = st.columns(2)

        with col1:
            # 月度提交数 vs 年度提交数散点图
            fig1 = px.scatter(
                df, x='annual_commit_rate', y='month_commit_rate',
                color='comprehensive_score', size='total_projects',
                hover_name='canonical_name',
                title='月度提交数 vs 年度提交数',
                labels={'annual_commit_rate': '年度提交数', 'month_commit_rate': '月度提交数'},
                color_continuous_scale='Viridis'
            )
            st.plotly_chart(fig1, use_container_width=True)

        with col2:
            # 月度新增行数 vs 年度新增行数散点图
            fig2 = px.scatter(
                df, x='annual_total_additions', y='month_total_additions',
                color='comprehensive_score', size='active_days',
                hover_name='canonical_name',
                title='月度新增行数 vs 年度新增行数',
                labels={'annual_total_additions': '年度新增行数', 'month_total_additions': '月度新增行数'},
                color_continuous_scale='Plasma'
            )
            st.plotly_chart(fig2, use_container_width=True)

        # 第二部分：项目参与度分析
        st.markdown("#### 🚀 项目参与度分析")
        col3, col4 = st.columns(2)

        with col3:
            # 项目总数 vs 年均项目数
            fig3 = px.scatter(
                df, x='total_projects', y='projects_per_year',
                color='consistency_ratio', size='comprehensive_score',
                hover_name='canonical_name',
                title='项目总数 vs 年均项目数',
                labels={'total_projects': '项目总数', 'projects_per_year': '年均项目数'},
                color_continuous_scale='Blues'
            )
            st.plotly_chart(fig3, use_container_width=True)

        with col4:
            # 年均项目数柱状图（前10名）
            top10_projects = df.head(10)
            fig4 = px.bar(
                top10_projects, x='canonical_name', y='projects_per_year',
                color='total_projects',
                title='年均项目参与数（前10名）',
                labels={'canonical_name': '贡献者', 'projects_per_year': '年均项目数'},
                color_continuous_scale='Greens'
            )
            fig4.update_layout(xaxis_tickangle=-45)
            st.plotly_chart(fig4, use_container_width=True)

        # 第三部分：活跃度与代码质量分析
        st.markdown("#### ⚡ 活跃度与代码质量分析")
        col5, col6 = st.columns(2)

        with col5:
            # 活跃天数 vs 一致性比例
            fig5 = px.scatter(
                df, x='active_days', y='consistency_ratio',
                color='additions_ratio', size='comprehensive_score',
                hover_name='canonical_name',
                title='活跃天数 vs 一致性比例',
                labels={'active_days': '活跃天数', 'consistency_ratio': '一致性比例(%)'},
                color_continuous_scale='Oranges'
            )
            st.plotly_chart(fig5, use_container_width=True)

        with col6:
            # 新增代码占比分布
            fig6 = px.histogram(
                df, x='additions_ratio', nbins=20,
                title='新增代码占比分布',
                labels={'additions_ratio': '新增代码占比(%)', 'count': '人数'},
                color_discrete_sequence=['#FF6B6B']
            )
            st.plotly_chart(fig6, use_container_width=True)

        # 第四部分：综合评分与四维评估
        st.markdown("#### 🏆 综合评分与四维评估")

        # 综合评分横向柱状图
        fig7 = px.bar(
            df, x='comprehensive_score', y='canonical_name',
            color='comprehensive_rating',
            title='综合评分排行',
            labels={'comprehensive_score': '综合评分', 'canonical_name': '贡献者'},
            orientation='h',
            color_discrete_map={
                '优秀': '#2E8B57',
                '良好': '#4682B4',
                '一般': '#DAA520',
                '需改进': '#CD5C5C'
            }
        )
        st.plotly_chart(fig7, use_container_width=True)

    def display_detailed_analysis(self, config: Dict):
        """显示详细分析"""
        st.markdown("## 📈 详细分析")

        # 获取综合分析数据
        df = self.analyzer.get_comprehensive_analysis(
            gitlab_url=config['gitlab_url'],
            start_date=config['start_date'],
            end_date=config['end_date'],
            min_active_days=config['min_active_days'],
            use_6month_view=config['use_6month_view']
        )

        if df.empty:
            st.warning("暂无数据")
            return

        # 选择分析对象
        selected_user = st.selectbox(
            "选择要分析的贡献者",
            options=df['canonical_name'].tolist(),
            help="选择一个贡献者查看详细分析",
            key="gitlab_selected_user"
        )

        if not selected_user:
            return

        user_data = df[df['canonical_name'] == selected_user].iloc[0]

        # 显示个人概览
        self._display_individual_overview(user_data)

        # 显示四维评估详情
        if config['show_detailed_metrics']:
            self._display_four_dimension_analysis(user_data)

        # 显示趋势分析
        if config['show_trend_analysis']:
            self._display_trend_analysis(config, selected_user)

    def _display_individual_overview(self, user_data: pd.Series):
        """显示个人概览"""
        st.markdown(f"### 👤 {user_data['canonical_name']} 的贡献概览")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("#### 📊 核心指标")
            st.metric("月度提交率", f"{user_data['month_commit_rate']:.1f}")
            st.metric("年度提交率", f"{user_data['annual_commit_rate']:.1f}")
            st.metric("月度新增行数", f"{user_data['month_total_additions']:,.0f}")
            st.metric("年度新增行数", f"{user_data['annual_total_additions']:,.0f}")

        with col2:
            st.markdown("#### 🏆 评估结果")
            st.metric("综合评分", f"{user_data['comprehensive_score']:.1f}/1000")
            st.metric("综合评级", user_data['comprehensive_rating'])
            st.metric("贡献等级", user_data['contribution_level'])
            st.metric("活跃天数", f"{user_data['active_days']}天")

    def _display_four_dimension_analysis(self, user_data: pd.Series):
        """显示四维评估分析"""
        st.markdown("### 🔍 四维评估详情")

        # 创建四维雷达图
        dimensions = {
            '工作习惯': user_data['work_habit_score'],
            '项目参与度': user_data['project_participation_score'],
            '持续性': user_data['consistency_total_score'],
            '协作能力': user_data['collaboration_ability_score']
        }

        fig = go.Figure()

        fig.add_trace(go.Scatterpolar(
            r=list(dimensions.values()),
            theta=list(dimensions.keys()),
            fill='toself',
            name=user_data['canonical_name'],
            line_color='rgb(1,90,180)'
        ))

        fig.update_layout(
            polar=dict(
                radialaxis=dict(
                    visible=True,
                    range=[0, 600]  # 设置为最大维度分数（项目参与度600分）
                )
            ),
            showlegend=True,
            title="四维评估雷达图"
        )

        st.plotly_chart(fig, use_container_width=True)

        # 详细评分展示
        col1, col2 = st.columns(2)

        with col1:
            st.markdown("#### 🏢 项目参与度评估 (450分)")
            st.progress(user_data['project_participation_score'] / 450)
            st.write(f"总分: {user_data['project_participation_score']:.1f}/450")
            st.write(f"- 月提交率: {user_data['monthly_commit_score']:.1f}/200")
            st.write(f"- 月新增行数: {user_data['monthly_additions_score']:.1f}/200")
            st.write(f"- 项目数量: {user_data['project_count_score']:.1f}/50")

            st.markdown("#### 📅 持续性评估 (250分)")
            st.progress(user_data['consistency_total_score'] / 250)
            st.write(f"总分: {user_data['consistency_total_score']:.1f}/250")
            st.write(f"- 活跃天数: {user_data['active_days_score']:.1f}/100")
            st.write(f"- 一致性: {user_data['consistency_score']:.1f}/100")
            st.write(f"- 月度提交: {user_data['monthly_rate_score']:.1f}/50")

        with col2:
            st.markdown("#### ⏰ 工作习惯评估 (250分)")
            st.progress(user_data['work_habit_score'] / 250)
            st.write(f"总分: {user_data['work_habit_score']:.1f}/250")
            st.write(f"- 工作时间: {user_data['work_time_score']:.1f}/60")
            st.write(f"- 工作日规律: {user_data['weekday_score']:.1f}/115")
            st.write(f"- 活跃时间: {user_data['active_hours_score']:.1f}/75")

            st.markdown("#### 🤝 协作能力评估 (300分)")
            st.progress(user_data['collaboration_ability_score'] / 300)
            st.write(f"总分: {user_data['collaboration_ability_score']:.1f}/300")
            st.write(f"- 协作广度: {user_data['collaboration_breadth_score']:.1f}/120")
            st.write(f"- 技术影响力: {user_data['technical_influence_score']:.1f}/130")

    def _display_trend_analysis(self, config: Dict, selected_user: str):
        """显示趋势分析"""
        st.markdown("### 📈 趋势分析")
        st.markdown("*比较全年数据与半年数据的表现趋势*")

        # 获取趋势分析数据
        trend_df = self.analyzer.get_trend_analysis(
            gitlab_url=config['gitlab_url'],
            start_date=config['start_date'],
            end_date=config['end_date'],
            min_active_days=config['min_active_days']
        )

        if trend_df.empty:
            st.warning("暂无趋势分析数据")
            return

        # 筛选当前用户的数据
        user_trend = trend_df[trend_df['canonical_name'] == selected_user]

        if user_trend.empty:
            st.warning(f"未找到 {selected_user} 的趋势分析数据")
            return

        user_trend = user_trend.iloc[0]

        # 显示趋势概览
        col1, col2 = st.columns(2)

        with col1:
            st.markdown("#### 📊 各维度趋势")

            trend_metrics = [
                ('project_participation_score', '项目参与度'),
                ('work_habit_score', '工作习惯'),
                ('consistency_total_score', '持续性'),
                ('collaboration_ability_score', '协作能力'),
                ('comprehensive_score', '综合评分')
            ]

            for metric, name in trend_metrics:
                trend_value = user_trend[f'{metric}_trend']
                trend_ratio = user_trend[f'{metric}_trend_ratio']

                # 根据趋势设置颜色
                if '提升' in trend_value:
                    color = '🟢'
                elif '下降' in trend_value:
                    color = '🔴'
                else:
                    color = '🟡'

                st.write(f"{color} **{name}**: {trend_value} ({trend_ratio:.2f}x)")

        with col2:
            st.markdown("#### 📈 趋势可视化")

            # 创建趋势比较图
            metrics_data = []
            for metric, name in trend_metrics:
                full_score = user_trend[f'{metric}_full']
                six_month_score = user_trend[f'{metric}_6m'] * 2  # 年化半年数据

                metrics_data.append({
                    '维度': name,
                    '全年数据': full_score,
                    '半年数据(年化)': six_month_score
                })

            metrics_df = pd.DataFrame(metrics_data)

            fig = go.Figure()

            fig.add_trace(go.Bar(
                name='全年数据',
                x=metrics_df['维度'],
                y=metrics_df['全年数据'],
                marker_color='lightblue'
            ))

            fig.add_trace(go.Bar(
                name='半年数据(年化)',
                x=metrics_df['维度'],
                y=metrics_df['半年数据(年化)'],
                marker_color='orange'
            ))

            fig.update_layout(
                title=f'{selected_user} 的趋势对比',
                xaxis_title='评估维度',
                yaxis_title='评分',
                barmode='group',
                height=400
            )

            st.plotly_chart(fig, use_container_width=True)

        # 显示趋势解读
        st.markdown("#### 💡 趋势解读")

        positive_trends = []
        negative_trends = []
        stable_trends = []

        for metric, name in trend_metrics:
            trend_value = user_trend[f'{metric}_trend']
            if '提升' in trend_value:
                positive_trends.append(f"{name}({trend_value})")
            elif '下降' in trend_value:
                negative_trends.append(f"{name}({trend_value})")
            else:
                stable_trends.append(f"{name}({trend_value})")

        if positive_trends:
            st.success(f"**表现提升的维度**: {', '.join(positive_trends)}")

        if stable_trends:
            st.info(f"**表现稳定的维度**: {', '.join(stable_trends)}")

        if negative_trends:
            st.warning(f"**需要关注的维度**: {', '.join(negative_trends)}")

    def _render_ai_report_section(self, df: pd.DataFrame):
        """渲染AI智能报告生成区域"""
        st.markdown("### 🤖 AI智能分析报告")

        col1, col2 = st.columns([3, 1])

        with col1:
            st.markdown("""
            基于贡献者数据，使用AI大模型生成深度分析报告，包含：
            - 团队整体表现分析
            - 个人贡献者画像
            - 数据洞察与建议
            - 量化指标解读
            """)

        with col2:
            generate_report = st.button(
                "🚀 生成AI报告",
                type="primary",
                use_container_width=True
            )

        if generate_report:
            try:
                # 初始化报告生成器
                llm_provider = os.getenv('LLM_PROVIDER', 'dashscope')

                if llm_provider == 'dashscope':
                    report_generator = ContributorReportGenerator(
                        llm_provider="dashscope",
                        model_name=os.getenv('QWEN_MODEL', 'qwen-plus'),
                        dashscope_api_key=os.getenv('DASHSCOPE_API_KEY')
                    )
                else:  # ollama
                    report_generator = ContributorReportGenerator(
                        llm_provider="ollama",
                        ollama_base_url=os.getenv('OLLAMA_BASE_URL', 'http://localhost:11434'),
                        model_name=os.getenv('OLLAMA_MODEL', 'qwen2.5:32b')
                    )

                # 显示报告标题和状态
                st.markdown("#### 📋 AI分析报告")

                # 创建状态显示区域
                status_container = st.container()
                with status_container:
                    st.info("🤖 **AI正在实时分析数据并生成报告...** 请耐心等待，内容将逐步显示")

                # 创建报告内容显示区域
                st.markdown("---")
                report_container = st.empty()
                accumulated_content = ""

                # 添加一个进度提示
                progress_text = st.empty()
                chunk_count = 0

                # 流式生成并显示报告
                for chunk in report_generator.generate_report_stream(df):
                    chunk_count += 1
                    accumulated_content += chunk

                    # 更新进度提示
                    progress_text.text(f"📝 已生成 {chunk_count} 个内容片段...")

                    # 实时更新显示内容
                    with report_container.container():
                        st.markdown(accumulated_content)

                    # 添加小延迟以便用户看到流式效果
                    import time
                    time.sleep(0.1)

                # 清除进度提示
                progress_text.empty()

                # 更新状态为完成
                with status_container:
                    st.success("✅ **AI分析报告生成完成！** 共生成了 {} 个内容片段".format(chunk_count))

                # 提供下载功能
                st.markdown("---")
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                filename = f"ai_analysis_report_{timestamp}.md"

                col1, col2 = st.columns([1, 1])
                with col1:
                    st.download_button(
                        label="📥 下载完整报告(Markdown)",
                        data=accumulated_content,
                        file_name=filename,
                        mime="text/markdown",
                        key=f"download_report_{timestamp}",
                        use_container_width=True
                    )

                with col2:
                    if st.button("🔄 重新生成报告", use_container_width=True, key=f"regenerate_{timestamp}"):
                        st.rerun()

            except Exception as e:
                st.error(f"❌ 生成报告时发生错误: {str(e)}")
                st.info("💡 **建议检查：**\n- Ollama服务是否正常运行\n- 网络连接是否正常\n- 模型是否已正确加载")
                logger.error(f"AI报告生成失败: {e}")

        st.markdown("---")

    def _identify_commit_decline(self, df: pd.DataFrame) -> pd.DataFrame:
        """识别半年提交血崩的开发者"""
        df = df.copy()

        # 计算半年提交量下降比例
        df['commit_decline_ratio'] = 0.0
        df['is_commit_decline'] = False

        if 'recent_6m_annual_commit_rate' in df.columns and 'annual_commit_rate' in df.columns:
            # 只对有足够历史数据的开发者进行分析（避免新人被误判）
            # 要求历史年化提交率 > 某个阈值（比如50）
            sufficient_history_mask = df['annual_commit_rate'] > 50

            # 计算下降比例：(历史年化 - 半年年化) / 历史年化
            df.loc[sufficient_history_mask, 'commit_decline_ratio'] = (
                    (df.loc[sufficient_history_mask, 'annual_commit_rate'] -
                     df.loc[sufficient_history_mask, 'recent_6m_annual_commit_rate']) /
                    df.loc[sufficient_history_mask, 'annual_commit_rate'] * 100
            ).clip(lower=0)  # 确保不会出现负值

            # 识别血崩：下降超过50%且历史提交率足够高
            decline_mask = (
                    (df['commit_decline_ratio'] > 50) &  # 提高阈值到50%
                    (df['annual_commit_rate'] > 100) &  # 历史年化提交数 > 100
                    (df['recent_6m_annual_commit_rate'] > 0)  # 最近6个月还有提交
            )
            df['is_commit_decline'] = decline_mask

        return df

    def _render_decline_analysis_charts(self, df: pd.DataFrame):
        """渲染提交下降分析图表"""
        # 筛选血崩开发者
        decline_df = df[df.get('is_commit_decline', False)].copy()

        if decline_df.empty:
            st.info("📊 当前没有检测到半年提交量骤降的开发者")
            return

        st.markdown("### 🚨 半年提交量骤降分析")
        st.markdown(f"**检测到 {len(decline_df)} 位开发者存在提交量显著下降**")

        col1, col2 = st.columns(2)

        with col1:
            # 提交量骤降趋势图
            fig1 = go.Figure()

            for _, row in decline_df.iterrows():
                fig1.add_trace(go.Scatter(
                    x=['历史年化提交', '半年年化提交'],
                    y=[row['annual_commit_rate'], row['recent_6m_annual_commit_rate']],
                    mode='lines+markers',
                    name=row['canonical_name'],
                    line=dict(width=3),
                    marker=dict(size=8)
                ))

            fig1.update_layout(
                title='最近半年提交量骤降趋势图',
                xaxis_title='时间维度',
                yaxis_title='年化提交数',
                hovermode='x unified',
                annotations=[
                    dict(
                        text="⚠️ 红色区域表示异常下降",
                        showarrow=False,
                        xref="paper", yref="paper",
                        x=0.02, y=0.98, xanchor="left", yanchor="top",
                        bgcolor="rgba(255,255,255,0.8)",
                        bordercolor="red", borderwidth=1
                    )
                ]
            )

            # 添加异常区域标识
            fig1.add_hline(y=decline_df['recent_6m_annual_commit_rate'].mean(),
                           line_dash="dash", line_color="red",
                           annotation_text="平均半年提交线")
            st.plotly_chart(fig1, use_container_width=True)

        with col2:
            # 下降比例柱状图
            fig2 = px.bar(
                decline_df.sort_values('commit_decline_ratio', ascending=False),
                x='canonical_name',
                y='commit_decline_ratio',
                title='提交量下降比例排行',
                labels={'commit_decline_ratio': '下降比例(%)', 'canonical_name': '开发者'},
                color='commit_decline_ratio',
                color_continuous_scale='Reds',
                hover_data=['annual_commit_rate', 'recent_6m_annual_commit_rate']
            )
            fig2.update_layout(
                xaxis_tickangle=-45,
                annotations=[
                    dict(
                        text="🔍 点击柱状图查看详细数据",
                        showarrow=False,
                        xref="paper", yref="paper",
                        x=0.98, y=0.98, xanchor="right", yanchor="top",
                        bgcolor="rgba(255,255,255,0.8)",
                        bordercolor="blue", borderwidth=1
                    )
                ]
            )

            # 添加危险阈值线
            fig2.add_hline(y=50, line_dash="dash", line_color="orange",
                           annotation_text="高风险线(50%)")
            st.plotly_chart(fig2, use_container_width=True)

        # 项目参与度雷达图
        st.markdown("#### 🎯 项目参与度对比雷达图")
        self._render_participation_radar(decline_df)

        # 数据钻取详情
        st.markdown("#### 📊 详细数据钻取")
        # 修改：分析所有人，而不仅仅是血崩的开发者
        self._render_decline_details(df)

    def _render_activity_heatmap(self, df: pd.DataFrame):
        """渲染提交活跃度热力图"""
        # 模拟周活跃度数据（实际应从数据库获取）
        import numpy as np

        weeks = [f'第{i}周' for i in range(1, 27)]  # 半年26周
        developers = df['canonical_name'].tolist()[:10]  # 限制显示前10个

        # 生成模拟数据（实际应从数据库查询）
        activity_data = np.random.randint(0, 50, size=(len(developers), len(weeks)))

        # 标识异常低活跃度区域
        anomaly_threshold = np.percentile(activity_data, 20)  # 低于20%分位数视为异常

        fig = go.Figure(data=go.Heatmap(
            z=activity_data,
            x=weeks,
            y=developers,
            colorscale='RdYlBu_r',
            hoverongaps=False,
            colorbar=dict(title="提交数"),
            hovertemplate='<b>%{y}</b><br>%{x}: %{z}次提交<br>异常阈值: ' + f'{anomaly_threshold:.0f}' + '<extra></extra>'
        ))

        # 添加异常区域标注
        for i, dev in enumerate(developers):
            for j, week in enumerate(weeks):
                if activity_data[i][j] < anomaly_threshold:
                    fig.add_annotation(
                        x=week, y=dev,
                        text="⚠️",
                        showarrow=False,
                        font=dict(color="red", size=12)
                    )

        fig.update_layout(
            title='开发者周提交活跃度热力图（最近半年）',
            xaxis_title='周次',
            yaxis_title='开发者',
            height=400,
            annotations=[
                dict(
                    text=f"⚠️ 红色警告标识异常低活跃度（<{anomaly_threshold:.0f}次）",
                    showarrow=False,
                    xref="paper", yref="paper",
                    x=0.02, y=1.02, xanchor="left", yanchor="bottom",
                    bgcolor="rgba(255,255,255,0.9)",
                    bordercolor="red", borderwidth=1
                )
            ]
        )

        st.plotly_chart(fig, use_container_width=True)

    def _render_participation_radar(self, df: pd.DataFrame):
        """渲染项目参与度雷达图"""
        # 选择前5个开发者进行对比
        top5_df = df.head(5)

        # 定义雷达图维度
        dimensions = ['提交频率', '代码质量', '项目参与', '协作能力', '持续性']

        fig = go.Figure()

        for i, (_, row) in enumerate(top5_df.iterrows()):
            # 计算各维度得分（基于现有数据）
            scores = [
                min(100, row.get('recent_6m_annual_commit_rate', 0) / 1000 * 20),  # 提交频率
                min(100, row.get('additions_ratio', 50)),  # 代码质量
                min(100, row.get('recent_6m_total_projects', 1) * 20),  # 项目参与
                min(100, row.get('consistency_ratio', 50)),  # 协作能力
                max(0, 100 - row.get('commit_decline_ratio', 0))  # 持续性（反向）
            ]

            fig.add_trace(go.Scatterpolar(
                r=scores,
                theta=dimensions,
                fill='toself',
                name=row['canonical_name'],
                line_color=px.colors.qualitative.Set1[i % len(px.colors.qualitative.Set1)]
            ))

        # 添加平均线作为对比基准
        avg_scores = [
            top5_df['recent_6m_annual_commit_rate'].mean() / 1000 * 20,
            top5_df.get('additions_ratio', pd.Series([50])).mean(),
            top5_df.get('recent_6m_total_projects', pd.Series([1])).mean() * 20,
            top5_df.get('consistency_ratio', pd.Series([50])).mean(),
            100 - top5_df.get('commit_decline_ratio', pd.Series([0])).mean()
        ]

        fig.add_trace(go.Scatterpolar(
            r=avg_scores,
            theta=dimensions,
            fill='toself',
            name='团队平均水平',
            line=dict(color='gray', dash='dash', width=2),
            fillcolor='rgba(128,128,128,0.1)'
        ))

        fig.update_layout(
            polar=dict(
                radialaxis=dict(
                    visible=True,
                    range=[0, 100],
                    tickmode='linear',
                    tick0=0,
                    dtick=20
                )
            ),
            title='开发者多维能力对比雷达图（vs团队平均）',
            showlegend=True,
            hovermode='closest',
            annotations=[
                dict(
                    text="💡 灰色虚线为团队平均水平",
                    showarrow=False,
                    xref="paper", yref="paper",
                    x=0.02, y=0.02, xanchor="left", yanchor="bottom",
                    bgcolor="rgba(255,255,255,0.8)",
                    bordercolor="gray", borderwidth=1
                )
            ]
        )

        st.plotly_chart(fig, use_container_width=True)

    def _render_decline_details(self, df: pd.DataFrame):
        """渲染完整人员清单数据表格，包含半年数据和完整数据的对比"""
        if df.empty:
            st.warning("暂无数据")
            return

        st.markdown("##### 📋 完整人员清单数据表格")
        st.markdown("*包含年化提交数、年化新增行数、活跃天数、项目参与数等核心指标的半年对比分析*")

        # 准备完整数据表格
        table_data = []

        for _, row in df.iterrows():
            # 计算变化率的辅助函数
            def calc_change_rate(recent_val, historical_val):
                if historical_val == 0:
                    return "N/A" if recent_val == 0 else "+∞"
                change_rate = ((recent_val - historical_val) / historical_val) * 100
                return f"{change_rate:+.1f}%"

            # 获取数据，提供默认值
            annual_commit = row.get('annual_commit_rate', 0)
            recent_6m_annual_commit = row.get('recent_6m_annual_commit_rate', 0)
            annual_additions = row.get('annual_total_additions', 0)
            recent_6m_annual_additions = row.get('recent_6m_annual_additions', 0)
            active_days = row.get('active_days', 0)
            recent_6m_active_days = row.get('recent_6m_active_days', 0)
            total_projects = row.get('total_projects', 0)
            recent_6m_total_projects = row.get('recent_6m_total_projects', 0)

            table_data.append({
                '开发者': row.get('canonical_name', 'Unknown'),
                '综合评分': f"{row.get('comprehensive_score', 0):.1f}",
                '综合评级': row.get('comprehensive_rating', 'N/A'),

                # 年化提交数对比
                '历史年化提交数': f"{annual_commit:,.0f}",
                '半年年化提交数': f"{recent_6m_annual_commit:,.0f}",
                '提交数变化率': calc_change_rate(recent_6m_annual_commit, annual_commit),

                # 年化新增行数对比
                '历史年化新增行数': f"{annual_additions:,.0f}",
                '半年年化新增行数': f"{recent_6m_annual_additions:,.0f}",
                '新增行数变化率': calc_change_rate(recent_6m_annual_additions, annual_additions),

                # 活跃天数对比
                '历史活跃天数': f"{active_days:,.0f}",
                '半年活跃天数': f"{recent_6m_active_days:,.0f}",
                '活跃天数变化率': calc_change_rate(recent_6m_active_days, active_days),

                # 项目参与数对比
                '历史项目参与数': f"{total_projects:,.0f}",
                '半年项目参与数': f"{recent_6m_total_projects:,.0f}",
                '项目参与数变化率': calc_change_rate(recent_6m_total_projects, total_projects),

                # 风险评估
                '提交下降比例': f"{row.get('commit_decline_ratio', 0):.1f}%",
                '风险等级': self._get_risk_level(row.get('commit_decline_ratio', 0), row.get('comprehensive_score', 0))
            })

        # 创建DataFrame并显示
        complete_df = pd.DataFrame(table_data)

        # 按综合评分排序
        complete_df = complete_df.sort_values('综合评分', ascending=False,
                                              key=lambda x: pd.to_numeric(x, errors='coerce'))

        # 显示数据表格
        st.dataframe(
            complete_df,
            use_container_width=True,
            hide_index=True,
            column_config={
                '开发者': st.column_config.TextColumn('开发者', width='medium'),
                '综合评分': st.column_config.NumberColumn('综合评分', format='%.1f'),
                '综合评级': st.column_config.TextColumn('综合评级', width='small'),
                '历史年化提交数': st.column_config.NumberColumn('历史年化提交数'),
                '半年年化提交数': st.column_config.NumberColumn('半年年化提交数'),
                '提交数变化率': st.column_config.TextColumn('提交数变化率', width='small'),
                '历史年化新增行数': st.column_config.NumberColumn('历史年化新增行数'),
                '半年年化新增行数': st.column_config.NumberColumn('半年年化新增行数'),
                '新增行数变化率': st.column_config.TextColumn('新增行数变化率', width='small'),
                '历史活跃天数': st.column_config.NumberColumn('历史活跃天数'),
                '半年活跃天数': st.column_config.NumberColumn('半年活跃天数'),
                '活跃天数变化率': st.column_config.TextColumn('活跃天数变化率', width='small'),
                '历史项目参与数': st.column_config.NumberColumn('历史项目参与数'),
                '半年项目参与数': st.column_config.NumberColumn('半年项目参与数'),
                '项目参与数变化率': st.column_config.TextColumn('项目参与数变化率', width='small'),
                '提交下降比例': st.column_config.TextColumn('提交下降比例', width='small'),
                '风险等级': st.column_config.TextColumn('风险等级', width='small')
            }
        )

        # 显示统计摘要
        st.markdown("##### 📊 数据统计摘要")
        col1, col2, col3, col4 = st.columns(4)

        with col1:
            st.metric("总人数", len(complete_df))

        with col2:
            high_risk_count = len(complete_df[complete_df['风险等级'].str.contains('高风险', na=False)])
            st.metric("高风险人数", high_risk_count, delta=f"{high_risk_count / len(complete_df) * 100:.1f}%")

        with col3:
            excellent_count = len(complete_df[complete_df['风险等级'].str.contains('优秀', na=False)])
            st.metric("优秀表现人数", excellent_count, delta=f"{excellent_count / len(complete_df) * 100:.1f}%")

        with col4:
            # 计算平均综合评分
            avg_score = pd.to_numeric(complete_df['综合评分'], errors='coerce').mean()
            st.metric("平均综合评分", f"{avg_score:.1f}")

        # 提供数据导出功能
        st.markdown("##### 📥 数据导出")
        csv_data = complete_df.to_csv(index=False, encoding='utf-8-sig')
        st.download_button(
            label="📥 下载完整数据表格 (CSV)",
            data=csv_data,
            file_name=f"人员清单数据表格_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.csv",
            mime="text/csv",
            help="下载包含所有指标的完整人员数据表格"
        )

    def _get_risk_level(self, decline_ratio: float, comprehensive_score: float) -> str:
        """根据下降比例和综合评分确定风险等级"""
        if decline_ratio > 50:
            return "🔴 高风险"
        elif decline_ratio > 30:
            return "🟡 中风险"
        elif comprehensive_score > 80:
            return "🟢 优秀表现"
        elif comprehensive_score > 60:
            return "🟢 正常表现"
        else:
            return "🟡 需要关注"

    def display_platform_info(self):
        """显示平台信息"""
        st.markdown("---")
        st.markdown(
            "**GitLab分析平台** | 基于核心指标和四维评估体系 | "
            "专注于：annual_commit_rate, month_commit_rate, annual_total_additions, month_total_additions"
        )
